home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 20 / Cream of the Crop 20 (Terry Blount) (1996).iso / os2 / sysb091a.zip / sysbench / src / pmb_bench.c < prev    next >
C/C++ Source or Header  |  1996-05-27  |  17KB  |  747 lines
  1.  
  2. /* Main benchmark file */
  3.  
  4. #define INCL_DOSMISC
  5. #define INCL_DOSPROCESS
  6. #include <os2.h>
  7.  
  8. #include <stdlib.h>
  9. #include <stdio.h>
  10. #include <time.h>
  11. #include "types.h"
  12. #include "pmb_bench.h"
  13. #include "pmb_datatype.h"
  14.  
  15.  
  16. #define KB 1024
  17. #define MB (1204*1204)
  18. #define d1 (12345678.901*(((double)rand())/RAND_MAX+0.5))
  19. #define d2 (12.345678901*(((double)rand())/RAND_MAX+0.5))
  20. #define MIN_DHRY_TIME 10.0
  21. #define MIN_MEASURE 0.1
  22. #define MARGINAL 1.1
  23.  
  24. static bool mult;  // true -> runs multiple tests in one thread
  25. static void* p;
  26.  
  27. extern void PostFin(int onlyupdate);
  28. double dtime(void);
  29. static void EndBench(void);
  30.  
  31. //extern bool str_has_value[STR_LINES]; // true == the line contains a valid computed value
  32. //extern bool str_is_new[STR_LINES]; // true == value has been changed since last update
  33. //extern double str_value[STR_LINES];
  34.  
  35. //extern char* str_init[];
  36. extern struct glob_data data;
  37. //static double val_cpufloat[3];
  38. //static double val_cpuint[4];
  39. //static double val_gfx[6];
  40. //static double val_mem[5];
  41.  
  42. void
  43. DoAll(void* p) {
  44.   mult = true;
  45.   DoAllGraphics(p);
  46.   DoAllCPUInt(p);
  47.   DoAllCPUFloat(p);
  48.   DoAllDIVE(p);
  49.   DoAllDiskIO(p);
  50.   DoAllMem(p);
  51.   mult = false;
  52.   PostFin(false);
  53. }
  54.  
  55. void
  56. DoAllCPUFloat(void* p) {
  57.   if (!mult) {
  58.     mult = true;
  59.     DoCPUFloatLinpack(p);
  60.     DoCPUFloatFlops(p);
  61.     DoCPUFloatFFT(p);
  62.     mult = false;
  63.     PostFin(false);
  64.   } else {
  65.     DoCPUFloatLinpack(p);
  66.     DoCPUFloatFlops(p);
  67.     DoCPUFloatFFT(p);
  68.   }
  69. }
  70.  
  71. void
  72. DoAllCPUInt(void* p) {
  73.   if (!mult) {
  74.     mult = true;
  75.     DoCPUIntDhry(p);
  76.     DoCPUIntHanoi(p);
  77.     DoCPUIntHeaps(p);
  78.     DoCPUIntSieve(p);
  79.     mult = false;
  80.     PostFin(false);
  81.   } else {
  82.     DoCPUIntDhry(p);
  83.     DoCPUIntHanoi(p);
  84.     DoCPUIntHeaps(p);
  85.     DoCPUIntSieve(p);
  86.   }
  87. }
  88.  
  89. void
  90. DoAllDIVE(void* p) {
  91.   if (!mult) {
  92.     mult = true;
  93.     DoDiveVBW(p);
  94.     DoDiveRot(p);
  95.     DoDiveMS11(p);
  96.     mult = false;
  97.     PostFin(false);
  98.   } else {
  99.     DoDiveVBW(p);
  100.     DoDiveRot(p);
  101.     DoDiveMS11(p);
  102.   }
  103. }
  104.  
  105. void
  106. DoAllDiskIO(void* p) {
  107.   if (!mult) {
  108.     mult = true;
  109.     DoDiskIOAvSeek(p);
  110.     DoDiskCacheXfer(p);
  111.     DoDiskIOTransSpeed(p);
  112.     DoDiskIOCPUUsage(p);
  113.     mult = false;
  114.     PostFin(false);
  115.   } else {
  116.     DoDiskIOAvSeek(p);
  117.     DoDiskCacheXfer(p);
  118.     DoDiskIOTransSpeed(p);
  119.     DoDiskIOCPUUsage(p);
  120.   }
  121. }
  122.  
  123. void
  124. DoAllGraphics(void* p) {
  125.   if (!mult) {
  126.     mult = true;
  127.     DoGfxBlitBlitSS(p);
  128.     DoGfxBlitBlitMS(p);
  129.     DoGfxFillRect(p);
  130.     DoGfxPatFil(p);
  131.     DoGfxVLines(p);
  132.     DoGfxHLines(p);
  133.     DoGfxDLines(p);
  134.     DoGfxTextRender(p);
  135.     mult = false;
  136.     PostFin(false);
  137.   } else {
  138.     DoGfxBlitBlitSS(p);
  139.     DoGfxBlitBlitMS(p);
  140.     DoGfxFillRect(p);
  141.     DoGfxPatFil(p);
  142.     DoGfxVLines(p);
  143.     DoGfxHLines(p);
  144.     DoGfxDLines(p);
  145.     DoGfxTextRender(p);
  146.   }
  147. }
  148.  
  149. void
  150. DoAllMem(void* p) {
  151.   if (!mult) {
  152.     mult = true;
  153.     DoMem5(p);
  154.     DoMem10(p);
  155.     DoMem20(p);
  156.     DoMem40(p);
  157.     DoMem80(p);
  158.     DoMem160(p);
  159.     DoMem320(p);
  160.     DoMem640(p);
  161.     DoMem1280(p);
  162.     DoMemR5(p);
  163.     DoMemR10(p);
  164.     DoMemR20(p);
  165.     DoMemR40(p);
  166.     DoMemR80(p);
  167.     DoMemR160(p);
  168.     DoMemR320(p);
  169.     DoMemR640(p);
  170.     DoMemR1280(p);
  171.     DoMemW5(p);
  172.     DoMemW10(p);
  173.     DoMemW20(p);
  174.     DoMemW40(p);
  175.     DoMemW80(p);
  176.     DoMemW160(p);
  177.     DoMemW320(p);
  178.     DoMemW640(p);
  179.     DoMemW1280(p);
  180.     mult = false;
  181.     PostFin(false);
  182.   } else {
  183.     DoMem5(p);
  184.     DoMem10(p);
  185.     DoMem20(p);
  186.     DoMem40(p);
  187.     DoMem80(p);
  188.     DoMem160(p);
  189.     DoMem320(p);
  190.     DoMem640(p);
  191.     DoMem1280(p);
  192.     DoMemR5(p);
  193.     DoMemR10(p);
  194.     DoMemR20(p);
  195.     DoMemR40(p);
  196.     DoMemR80(p);
  197.     DoMemR160(p);
  198.     DoMemR320(p);
  199.     DoMemR640(p);
  200.     DoMemR1280(p);
  201.     DoMemW5(p);
  202.     DoMemW10(p);
  203.     DoMemW20(p);
  204.     DoMemW40(p);
  205.     DoMemW80(p);
  206.     DoMemW160(p);
  207.     DoMemW320(p);
  208.     DoMemW640(p);
  209.     DoMemW1280(p);
  210.   }
  211. }
  212.  
  213. extern double pmb_fft(void);
  214.  
  215. void
  216. DoCPUFloatFFT(void* p) {
  217.   data.c[comp_cpufloat].datalines[cpufloat_fft].value = pmb_fft();
  218.   EndBench();
  219. }
  220.  
  221. extern double pmb_flops(void);
  222.  
  223. void
  224. DoCPUFloatFlops(void* p) {
  225.   data.c[comp_cpufloat].datalines[cpufloat_flops].value = pmb_flops();
  226.   EndBench();
  227. }
  228.  
  229. extern double pmb_linpack(void);
  230.  
  231. void
  232. DoCPUFloatLinpack(void* p) {
  233.   data.c[comp_cpufloat].datalines[cpufloat_linpack].value = pmb_linpack();
  234.   EndBench();
  235. }
  236.  
  237. extern double pmb_dhry(int);
  238.  
  239. void
  240. DoCPUIntDhry(void* p) {
  241.   double t1, t2, r, tot_time;
  242.   int loops;
  243.   loops = 1000;
  244.   while (1) {
  245.     t1 = dtime();
  246.     r = pmb_dhry(loops);
  247.     t2 = dtime();
  248.     tot_time = (t2-t1);
  249.     if (((tot_time) < MIN_DHRY_TIME) || (r < 0)) {
  250.       if ((tot_time) < MIN_MEASURE) {
  251.         loops = MIN_DHRY_TIME/MIN_MEASURE*loops;
  252.       } else {
  253.         loops = MIN_DHRY_TIME*MARGINAL/(tot_time)*loops;
  254.       }
  255.     } else {
  256.       break;
  257.     }
  258.   }
  259.   data.c[comp_cpuint].datalines[cpuint_dhrystone].value = r;
  260.   EndBench();
  261. }
  262.  
  263. extern double pmb_hanoi(void);
  264.  
  265. void
  266. DoCPUIntHanoi(void* p) {
  267.   data.c[comp_cpuint].datalines[cpuint_hanoi].value = pmb_hanoi();
  268.   EndBench();
  269. }
  270.  
  271. extern double pmb_heaps(void);
  272.  
  273. void
  274. DoCPUIntHeaps(void* p) {
  275.   data.c[comp_cpuint].datalines[cpuint_heapsort].value = pmb_heaps();
  276.   EndBench();
  277. }
  278.  
  279. extern double pmb_sieve(void);
  280.  
  281. void
  282. DoCPUIntSieve(void* p) {
  283.   data.c[comp_cpuint].datalines[cpuint_sieve].value = pmb_sieve();
  284.   EndBench();
  285. }
  286.  
  287. extern double pmb_diskio_avseek(int disknr);
  288.  
  289. void
  290. DoDiskIOAvSeek(void* p) {
  291.   data.c[comp_disk].datalines[disk_avseek].value = (pmb_diskio_avseek(data.selected_disk)/(10*1000));
  292.   EndBench();
  293. }
  294.  
  295. extern double pmb_buscache_xfer(int disknr);
  296.  
  297. void
  298. DoDiskCacheXfer(void* p) {
  299.   data.c[comp_disk].datalines[disk_busxfer].value = (pmb_buscache_xfer(data.selected_disk)*KB);
  300.   EndBench();
  301. }
  302.  
  303. extern double pmb_diskio_transfer(int disknr);
  304.  
  305. void
  306. DoDiskIOTransSpeed(void* p) {
  307.   data.c[comp_disk].datalines[disk_transf].value = (pmb_diskio_transfer(data.selected_disk)*KB);
  308.   EndBench();
  309. }
  310.  
  311. extern double pmb_diskio_cpupct(int disknr);
  312.  
  313. void
  314. DoDiskIOCPUUsage(void* p) {
  315.   data.c[comp_disk].datalines[disk_cpupct].value = (pmb_diskio_cpupct(data.selected_disk));
  316.   EndBench();
  317. }
  318.  
  319. extern double pmb_dive_bw(void);
  320.  
  321. void
  322. DoDiveVBW(void* p) {
  323.   double r;
  324.   //r = -1.0;
  325.   r = pmb_dive_bw();
  326.   if (r < 0) {
  327.     r = -1.0;
  328.   }
  329.   data.c[comp_dive].datalines[dive_videobw].value = r;
  330.   EndBench();
  331. }
  332.  
  333. extern double pmb_dive_rot(void);
  334.  
  335. void
  336. DoDiveRot(void* p) {
  337.   double r;
  338.   //r = -1.0;
  339.   r = pmb_dive_rot();
  340.   if (r < 0) {
  341.     r = -1.0;
  342.   }
  343.   data.c[comp_dive].datalines[dive_rotate].value = r;
  344.   EndBench();
  345. }
  346.  
  347. extern double pmb_dive_ms11(void);
  348.  
  349. void
  350. DoDiveMS11(void* p) {
  351.   double r;
  352.   //r = -1.0;
  353.   r = pmb_dive_ms11();
  354.   if (r < 0) {
  355.     r = -1.0;
  356.   }
  357.   data.c[comp_dive].datalines[dive_ms_11].value = r;
  358.   EndBench();
  359. }
  360.  
  361. extern double pmb_gfx_bitblitss(void);
  362.  
  363. void
  364. DoGfxBlitBlitSS(void* p) {
  365.   data.c[comp_gfx].datalines[gfx_bitblt_SS].value = pmb_gfx_bitblitss();
  366.   EndBench();
  367. }
  368.  
  369. extern double pmb_gfx_bitblitms(void);
  370.  
  371. void
  372. DoGfxBlitBlitMS(void* p) {
  373.   data.c[comp_gfx].datalines[gfx_bitblt_MS].value = pmb_gfx_bitblitms();
  374.   EndBench();
  375. }
  376.  
  377.  
  378. extern double pmb_gfx_dlines(void);
  379.  
  380. void
  381. DoGfxDLines(void* p) {
  382.   data.c[comp_gfx].datalines[gfx_dlines].value = pmb_gfx_dlines();
  383.   EndBench();
  384. }
  385.  
  386. extern double pmb_gfx_hlines(void);
  387.  
  388. void
  389. DoGfxHLines(void* p) {
  390.   data.c[comp_gfx].datalines[gfx_hlines].value = pmb_gfx_hlines();
  391.   EndBench();
  392. }
  393.  
  394. extern double pmb_gfx_patrect(void);
  395.  
  396. void
  397. DoGfxPatFil(void* p) {
  398.   data.c[comp_gfx].datalines[gfx_patt_fill].value = pmb_gfx_patrect();
  399.   EndBench();
  400. }
  401.  
  402. extern double pmb_gfx_fillrect(void);
  403.  
  404. void
  405. DoGfxFillRect(void* p) {
  406.   data.c[comp_gfx].datalines[gfx_filled_rect].value = pmb_gfx_fillrect();
  407.   EndBench();
  408. }
  409.  
  410. extern double pmb_gfx_textrender(void);
  411.  
  412. void
  413. DoGfxTextRender(void* p) {
  414.   data.c[comp_gfx].datalines[gfx_textrender].value = pmb_gfx_textrender();
  415.   EndBench();
  416. }
  417.  
  418. extern double pmb_gfx_vlines(v